home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1994 October / Macformat17.cdr / Shareware City / Developers / MacVogl-alpha1PPC / arcs.c next >
C/C++ Source or Header  |  1994-07-11  |  7KB  |  385 lines
  1. #include "vogl.h"
  2.  
  3. #ifdef    TC
  4.  
  5. extern    double    cos();
  6. extern    double    sin();
  7.  
  8. #else 
  9.  
  10. #include <math.h>
  11.  
  12. #endif
  13.  
  14. static int    nsegs = 32;
  15.  
  16. /*
  17.  * arcprecision
  18.  *
  19.  *    sets the number of segments in an arc or circle.
  20.  *    - obsolete function.
  21.  */
  22. void
  23. arcprecision(noseg)
  24.     int    noseg;
  25. {
  26.     nsegs = noseg;
  27. }
  28.  
  29. /*
  30.  * circleprecision
  31.  *
  32.  *    sets the number of segments in an arc or circle.
  33.  */
  34. void
  35. circleprecision(noseg)
  36.     int    noseg;
  37. {
  38.     nsegs = noseg;
  39. }
  40.  
  41. /*
  42.  * arc
  43.  *
  44.  * draw an arc at a given location.  Precision of arc (# line segments)
  45.  * is calculated from the value given to circleprecision.
  46.  *
  47.  */
  48. void
  49. arc(x, y, radius, sang, eang)
  50.     Coord    x, y, radius;
  51.     Angle    sang, eang;
  52. {
  53.     Token    *t;
  54.     double    cx, cy, dx, dy;
  55.     double    startang, endang, deltang, cosine, sine, angle;
  56.     int    i, numsegs;
  57.  
  58.     if (!vdevice.initialised)
  59.         verror("arc: vogl not initialised");
  60.  
  61.     startang = (double)sang / 10.0;
  62.     endang = (double)eang / 10.0;
  63.  
  64.     angle = startang * D2R;
  65.     numsegs = (endang - startang) / 360.0 * nsegs + 0.5;
  66.     deltang = (endang - startang) * D2R / numsegs;
  67.     cosine = cos((double)deltang);
  68.     sine = sin((double)deltang);
  69.  
  70.     if (vdevice.inobject) {
  71.         t = newtokens(8);
  72.         t[0].i = ARC;
  73.         t[1].f = x;
  74.         t[2].f = y;
  75.         t[3].f = radius * cos((double)angle);
  76.         t[4].f = radius * sin((double)angle);
  77.         t[5].f = cosine;
  78.         t[6].f = sine;
  79.         t[7].i = numsegs;
  80.         return;
  81.     }
  82.  
  83.     /* calculates initial point on arc */
  84.  
  85.     cx = x + radius * cos((double)angle);
  86.     cy = y + radius * sin((double)angle);
  87.     move2(cx, cy);
  88.  
  89.     for (i = 0; i < numsegs; i++)  {
  90.         dx = cx - x; 
  91.         dy = cy - y;
  92.         cx = x + dx * cosine - dy * sine;
  93.         cy = y + dx * sine + dy * cosine;
  94.         draw2(cx, cy);
  95.     }
  96. }
  97.  
  98. /*
  99.  * arcs
  100.  *
  101.  * draw an arc at a given location.  (Expressed as short integers) 
  102.  * Precision of arc (# line segments) is calculated from the value
  103.  * given to circleprecision.
  104.  *
  105.  */
  106. void
  107. arcs(x, y, radius, sang, eang)
  108.     Scoord    x, y, radius;
  109.     Angle    sang, eang;
  110. {
  111.     arc((Coord)x, (Coord)y, (Coord)radius, sang, eang);
  112. }
  113.  
  114. /*
  115.  * arci
  116.  *
  117.  * draw an arc at a given location.  (Expressed as integers) 
  118.  * Precision of arc (# line segments) is calculated from the value
  119.  * given to circleprecision.
  120.  *
  121.  */
  122. void
  123. arci(x, y, radius, sang, eang)
  124.     Icoord    x, y, radius;
  125.     Angle    sang, eang;
  126. {
  127.     arc((Coord)x, (Coord)y, (Coord)radius, sang, eang);
  128. }
  129.  
  130. /*
  131.  * arcf
  132.  *
  133.  *    draw a filled sector in a given location. The number of line
  134.  * segments in the arc of the segment is the same as in arc.
  135.  */
  136. void
  137. arcf(x, y, radius, sang, eang)
  138.     Coord    x, y, radius;
  139.     Angle    sang, eang;
  140. {
  141.     Token    *t;
  142.     double    cx, cy, dx, dy;
  143.     double    deltang, cosine, sine, angle;
  144.     int    i, numsegs;
  145.     double    startang, endang;
  146.  
  147.     if (!vdevice.initialised)
  148.         verror("arcf: vogl not initialised");
  149.  
  150.     startang = sang / 10.0;
  151.     endang = eang / 10.0;
  152.  
  153.     angle = startang * D2R;
  154.     numsegs = (endang - startang) / 360.0 * nsegs + 0.5;
  155.     deltang = (endang - startang) * D2R / numsegs;
  156.     cosine = cos((double)deltang);
  157.     sine = sin((double)deltang);
  158.  
  159.     if (vdevice.inobject) {
  160.         t = newtokens(8);
  161.         t[0].i = ARCF;
  162.         t[1].f = x;
  163.         t[2].f = y;
  164.         t[3].f = radius * cos((double)angle);
  165.         t[4].f = radius * sin((double)angle);
  166.         t[5].f = cosine;
  167.         t[6].f = sine;
  168.         t[7].i = numsegs;
  169.         return;
  170.     }
  171.  
  172.     pmv2(x, y);
  173.             /* calculates initial point on arc */
  174.  
  175.     cx = x + radius * cos((double)angle);
  176.     cy = y + radius * sin((double)angle);
  177.  
  178.     pdr2(cx, cy);
  179.  
  180.     for (i = 0; i < numsegs; i++)  {
  181.         dx = cx - x; 
  182.         dy = cy - y;
  183.         cx = x + dx * cosine - dy * sine;
  184.         cy = y + dx * sine + dy * cosine;
  185.         pdr2(cx, cy);
  186.     }
  187.  
  188.     pclos();
  189. }
  190.  
  191. /*
  192.  * arcfs
  193.  *
  194.  * draw a filled sector at a given location.  (Expressed as short integers) 
  195.  * Precision of arc (# line segments) is calculated from the value
  196.  * given to circleprecision.
  197.  *
  198.  */
  199. void
  200. arcfs(x, y, radius, sang, eang)
  201.     Scoord    x, y, radius;
  202.     Angle    sang, eang;
  203. {
  204.     arcf((Coord)x, (Coord)y, (Coord)radius, sang, eang);
  205. }
  206.  
  207. /*
  208.  * arcfi
  209.  *
  210.  * draw a filled sector at a given location.  (Expressed as integers) 
  211.  * Precision of arc (# line segments) is calculated from the value
  212.  * given to circleprecision.
  213.  *
  214.  */
  215. void
  216. arcfi(x, y, radius, sang, eang)
  217.     Icoord    x, y, radius;
  218.     Angle    sang, eang;
  219. {
  220.     arcf((Coord)x, (Coord)y, (Coord)radius, sang, eang);
  221. }
  222.  
  223.  
  224. /*
  225.  * circ
  226.  *
  227.  * Draw a circle of given radius at given world coordinates. The number of
  228.  * segments in the circle is the same as that of an arc.
  229.  *
  230.  */
  231. void
  232. circ(x, y, radius)
  233.     Coord    x, y, radius;
  234. {
  235.     Token    *t;
  236.     double    cx, cy, dx, dy;
  237.     double    angle, cosine, sine;
  238.     int    i;
  239.  
  240.     if (!vdevice.initialised)
  241.         verror("circ: vogl not initialised");
  242.  
  243.     angle = 2.0 * PI / nsegs;
  244.     cosine = cos((double)angle);
  245.     sine = sin((double)angle);
  246.  
  247.     if (vdevice.inobject) {
  248.         t = newtokens(7);
  249.         t[0].i = CIRCLE;
  250.         t[1].f = x;
  251.         t[2].f = y;
  252.         t[3].f = radius;
  253.         t[4].f = cosine;
  254.         t[5].f = sine;
  255.         t[6].i = nsegs;
  256.         return;
  257.     }
  258.  
  259.     cx = x + radius;
  260.     cy = y;
  261.  
  262.     move2(cx, cy);
  263.     for (i = 0; i < nsegs - 1; i++) {
  264.         dx = cx - x; 
  265.         dy = cy - y;
  266.         cx = x + dx * cosine - dy * sine;
  267.         cy = y + dx * sine + dy * cosine;
  268.         draw2(cx, cy);
  269.     }
  270.  
  271.     draw2(x + radius, y);
  272. }
  273.  
  274. /*
  275.  * circs
  276.  *
  277.  * Draw a circle of given radius at given world coordinates expressed as
  278.  * short integers. The number of segments in the circle is the same as that
  279.  * of an arc.
  280.  *
  281.  */
  282. void
  283. circs(x, y, radius)
  284.     Scoord    x, y, radius;
  285. {
  286.     circ((Coord)x, (Coord)y, (Coord)radius);
  287. }
  288.  
  289.  
  290. /*
  291.  * circi
  292.  *
  293.  * Draw a circle of given radius at given world coordinates expressed as
  294.  * integers. The number of segments in the circle is the same as that
  295.  * of an arc.
  296.  *
  297.  */
  298. void
  299. circi(x, y, radius)
  300.     Icoord    x, y, radius;
  301. {
  302.     circ((Coord)x, (Coord)y, (Coord)radius);
  303. }
  304.  
  305. /*
  306.  * circf
  307.  *
  308.  * Draw a filled circle of given radius at given world coordinates.
  309.  * The number of segments in the circle is the same as that of an arc.
  310.  *
  311.  */
  312. void
  313. circf(x, y, radius)
  314.     Coord    x, y, radius;
  315. {
  316.     Token    *t;
  317.     double    cx, cy, dx, dy;
  318.     double    angle, cosine, sine;
  319.     int    i;
  320.  
  321.     if (!vdevice.initialised)
  322.         verror("circf: vogl not initialised");
  323.  
  324.     angle = 2.0 * PI / nsegs;
  325.     cosine = cos((double)angle);
  326.     sine = sin((double)angle);
  327.  
  328.     if (vdevice.inobject) {
  329.         t = newtokens(7);
  330.         t[0].i = CIRCF;
  331.         t[1].f = x;
  332.         t[2].f = y;
  333.         t[3].f = radius;
  334.         t[4].f = cosine;
  335.         t[5].f = sine;
  336.         t[6].i = nsegs;
  337.         return;
  338.     }
  339.  
  340.     cx = x + radius;
  341.     cy = y;
  342.  
  343.     pmv2(cx, cy);
  344.     for (i = 0; i < nsegs - 1; i++) {
  345.         dx = cx - x; 
  346.         dy = cy - y;
  347.         cx = x + dx * cosine - dy * sine;
  348.         cy = y + dx * sine + dy * cosine;
  349.         pdr2(cx, cy);
  350.     }
  351.  
  352.     pclos();
  353. }
  354.  
  355. /*
  356.  * circfs
  357.  *
  358.  * Draw a circle of given radius at given world coordinates expressed as
  359.  * short integers. The number of segments in the circle is the same as that
  360.  * of an arc.
  361.  *
  362.  */
  363. void
  364. circfs(x, y, radius)
  365.     Scoord    x, y, radius;
  366. {
  367.     circf((Coord)x, (Coord)y, (Coord)radius);
  368. }
  369.  
  370. /*
  371.  * circfi
  372.  *
  373.  * Draw a circle of given radius at given world coordinates expressed as
  374.  * integers. The number of segments in the circle is the same as that
  375.  * of an arc.
  376.  *
  377.  */
  378. void
  379. circfi(x, y, radius)
  380.     Icoord    x, y, radius;
  381. {
  382.     circf((Coord)x, (Coord)y, (Coord)radius);
  383. }
  384.  
  385.